(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object')
        module.exports = factory(require("katex"));
    else if (typeof define === 'function' && define.amd)
        define(["katex"], factory);
    else {
        var a = typeof exports === 'object' ? factory(require("katex")) : factory(root["katex"]);
        for (var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
    }
})((typeof self !== 'undefined' ? self : this), function (__WEBPACK_EXTERNAL_MODULE__0__) {
    return /******/ (function (modules) { // webpackBootstrap
        /******/ 	// The module cache
        /******/
        var installedModules = {};
        /******/
        /******/ 	// The require function
        /******/
        function __webpack_require__(moduleId) {
            /******/
            /******/ 		// Check if module is in cache
            /******/
            if (installedModules[moduleId]) {
                /******/
                return installedModules[moduleId].exports;
                /******/
            }
            /******/ 		// Create a new module (and put it into the cache)
            /******/
            var module = installedModules[moduleId] = {
                /******/            i: moduleId,
                /******/            l: false,
                /******/            exports: {}
                /******/
            };
            /******/
            /******/ 		// Execute the module function
            /******/
            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/
            /******/ 		// Flag the module as loaded
            /******/
            module.l = true;
            /******/
            /******/ 		// Return the exports of the module
            /******/
            return module.exports;
            /******/
        }

        /******/
        /******/
        /******/ 	// expose the modules object (__webpack_modules__)
        /******/
        __webpack_require__.m = modules;
        /******/
        /******/ 	// expose the module cache
        /******/
        __webpack_require__.c = installedModules;
        /******/
        /******/ 	// define getter function for harmony exports
        /******/
        __webpack_require__.d = function (exports, name, getter) {
            /******/
            if (!__webpack_require__.o(exports, name)) {
                /******/
                Object.defineProperty(exports, name, {enumerable: true, get: getter});
                /******/
            }
            /******/
        };
        /******/
        /******/ 	// define __esModule on exports
        /******/
        __webpack_require__.r = function (exports) {
            /******/
            if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
                /******/
                Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
                /******/
            }
            /******/
            Object.defineProperty(exports, '__esModule', {value: true});
            /******/
        };
        /******/
        /******/ 	// create a fake namespace object
        /******/ 	// mode & 1: value is a module id, require it
        /******/ 	// mode & 2: merge all properties of value into the ns
        /******/ 	// mode & 4: return value when already ns object
        /******/ 	// mode & 8|1: behave like require
        /******/
        __webpack_require__.t = function (value, mode) {
            /******/
            if (mode & 1) value = __webpack_require__(value);
            /******/
            if (mode & 8) return value;
            /******/
            if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
            /******/
            var ns = Object.create(null);
            /******/
            __webpack_require__.r(ns);
            /******/
            Object.defineProperty(ns, 'default', {enumerable: true, value: value});
            /******/
            if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
                return value[key];
            }.bind(null, key));
            /******/
            return ns;
            /******/
        };
        /******/
        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = function (module) {
            /******/
            var getter = module && module.__esModule ?
                /******/            function getDefault() {
                    return module['default'];
                } :
                /******/            function getModuleExports() {
                    return module;
                };
            /******/
            __webpack_require__.d(getter, 'a', getter);
            /******/
            return getter;
            /******/
        };
        /******/
        /******/ 	// Object.prototype.hasOwnProperty.call
        /******/
        __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ 	// __webpack_public_path__
        /******/
        __webpack_require__.p = "";
        /******/
        /******/
        /******/ 	// Load entry module and return exports
        /******/
        return __webpack_require__(__webpack_require__.s = 1);
        /******/
    })
        /************************************************************************/
        /******/ ([
            /* 0 */
            /***/ (function (module, exports) {

                module.exports = __WEBPACK_EXTERNAL_MODULE__0__;

                /***/
            }),
            /* 1 */
            /***/ (function (module, __webpack_exports__, __webpack_require__) {

                "use strict";
                __webpack_require__.r(__webpack_exports__);
                /* harmony import */
                var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
                /* harmony import */
                var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(katex__WEBPACK_IMPORTED_MODULE_0__);
                /**
                 * renderA11yString returns a readable string.
                 *
                 * In some cases the string will have the proper semantic math
                 * meaning,:
                 *   renderA11yString("\\frac{1}{2}"")
                 *   -> "start fraction, 1, divided by, 2, end fraction"
                 *
                 * However, other cases do not:
                 *   renderA11yString("f(x) = x^2")
                 *   -> "f, left parenthesis, x, right parenthesis, equals, x, squared"
                 *
                 * The commas in the string aim to increase ease of understanding
                 * when read by a screenreader.
                 */
// NOTE: since we're importing types here these files won't actually be
// included in the build.
// $FlowIgnore: we import the types directly anyways

                var stringMap = {
                    "(": "left parenthesis",
                    ")": "right parenthesis",
                    "[": "open bracket",
                    "]": "close bracket",
                    "\\{": "left brace",
                    "\\}": "right brace",
                    "\\lvert": "open vertical bar",
                    "\\rvert": "close vertical bar",
                    "|": "vertical bar",
                    "\\uparrow": "up arrow",
                    "\\Uparrow": "up arrow",
                    "\\downarrow": "down arrow",
                    "\\Downarrow": "down arrow",
                    "\\updownarrow": "up down arrow",
                    "\\leftarrow": "left arrow",
                    "\\Leftarrow": "left arrow",
                    "\\rightarrow": "right arrow",
                    "\\Rightarrow": "right arrow",
                    "\\langle": "open angle",
                    "\\rangle": "close angle",
                    "\\lfloor": "open floor",
                    "\\rfloor": "close floor",
                    "\\int": "integral",
                    "\\intop": "integral",
                    "\\lim": "limit",
                    "\\ln": "natural log",
                    "\\log": "log",
                    "\\sin": "sine",
                    "\\cos": "cosine",
                    "\\tan": "tangent",
                    "\\cot": "cotangent",
                    "\\sum": "sum",
                    "/": "slash",
                    ",": "comma",
                    ".": "point",
                    "-": "negative",
                    "+": "plus",
                    "~": "tilde",
                    ":": "colon",
                    "?": "question mark",
                    "'": "apostrophe",
                    "\\%": "percent",
                    " ": "space",
                    "\\ ": "space",
                    "\\$": "dollar sign",
                    "\\angle": "angle",
                    "\\degree": "degree",
                    "\\circ": "circle",
                    "\\vec": "vector",
                    "\\triangle": "triangle",
                    "\\pi": "pi",
                    "\\prime": "prime",
                    "\\infty": "infinity",
                    "\\alpha": "alpha",
                    "\\beta": "beta",
                    "\\gamma": "gamma",
                    "\\omega": "omega",
                    "\\theta": "theta",
                    "\\sigma": "sigma",
                    "\\lambda": "lambda",
                    "\\tau": "tau",
                    "\\Delta": "delta",
                    "\\delta": "delta",
                    "\\mu": "mu",
                    "\\rho": "rho",
                    "\\nabla": "del",
                    "\\ell": "ell",
                    "\\ldots": "dots",
                    // TODO: add entries for all accents
                    "\\hat": "hat",
                    "\\acute": "acute"
                };
                var powerMap = {
                    "prime": "prime",
                    "degree": "degrees",
                    "circle": "degrees",
                    "2": "squared",
                    "3": "cubed"
                };
                var openMap = {
                    "|": "open vertical bar",
                    ".": ""
                };
                var closeMap = {
                    "|": "close vertical bar",
                    ".": ""
                };
                var binMap = {
                    "+": "plus",
                    "-": "minus",
                    "\\pm": "plus minus",
                    "\\cdot": "dot",
                    "*": "times",
                    "/": "divided by",
                    "\\times": "times",
                    "\\div": "divided by",
                    "\\circ": "circle",
                    "\\bullet": "bullet"
                };
                var relMap = {
                    "=": "equals",
                    "\\approx": "approximately equals",
                    "≠": "does not equal",
                    "\\geq": "is greater than or equal to",
                    "\\ge": "is greater than or equal to",
                    "\\leq": "is less than or equal to",
                    "\\le": "is less than or equal to",
                    ">": "is greater than",
                    "<": "is less than",
                    "\\leftarrow": "left arrow",
                    "\\Leftarrow": "left arrow",
                    "\\rightarrow": "right arrow",
                    "\\Rightarrow": "right arrow",
                    ":": "colon"
                };
                var accentUnderMap = {
                    "\\underleftarrow": "left arrow",
                    "\\underrightarrow": "right arrow",
                    "\\underleftrightarrow": "left-right arrow",
                    "\\undergroup": "group",
                    "\\underlinesegment": "line segment",
                    "\\utilde": "tilde"
                };

                var buildString = function buildString(str, type, a11yStrings) {
                    if (!str) {
                        return;
                    }

                    var ret;

                    if (type === "open") {
                        ret = str in openMap ? openMap[str] : stringMap[str] || str;
                    } else if (type === "close") {
                        ret = str in closeMap ? closeMap[str] : stringMap[str] || str;
                    } else if (type === "bin") {
                        ret = binMap[str] || str;
                    } else if (type === "rel") {
                        ret = relMap[str] || str;
                    } else {
                        ret = stringMap[str] || str;
                    } // If the text to add is a number and there is already a string
                    // in the list and the last string is a number then we should
                    // combine them into a single number


                    if (/^\d+$/.test(ret) && a11yStrings.length > 0 && // TODO(kevinb): check that the last item in a11yStrings is a string
                        // I think we might be able to drop the nested arrays, which would make
                        // this easier to type - $FlowFixMe
                        /^\d+$/.test(a11yStrings[a11yStrings.length - 1])) {
                        a11yStrings[a11yStrings.length - 1] += ret;
                    } else if (ret) {
                        a11yStrings.push(ret);
                    }
                };

                var buildRegion = function buildRegion(a11yStrings, callback) {
                    var regionStrings = [];
                    a11yStrings.push(regionStrings);
                    callback(regionStrings);
                };

                var handleObject = function handleObject(tree, a11yStrings, atomType) {
                    // Everything else is assumed to be an object...
                    switch (tree.type) {
                        case "accent": {
                            buildRegion(a11yStrings, function (a11yStrings) {
                                buildA11yStrings(tree.base, a11yStrings, atomType);
                                a11yStrings.push("with");
                                buildString(tree.label, "normal", a11yStrings);
                                a11yStrings.push("on top");
                            });
                            break;
                        }

                        case "accentUnder": {
                            buildRegion(a11yStrings, function (a11yStrings) {
                                buildA11yStrings(tree.base, a11yStrings, atomType);
                                a11yStrings.push("with");
                                buildString(accentUnderMap[tree.label], "normal", a11yStrings);
                                a11yStrings.push("underneath");
                            });
                            break;
                        }

                        case "accent-token": {
                            // Used internally by accent symbols.
                            break;
                        }

                        case "atom": {
                            var text = tree.text;

                            switch (tree.family) {
                                case "bin": {
                                    buildString(text, "bin", a11yStrings);
                                    break;
                                }

                                case "close": {
                                    buildString(text, "close", a11yStrings);
                                    break;
                                }
                                // TODO(kevinb): figure out what should be done for inner

                                case "inner": {
                                    buildString(tree.text, "inner", a11yStrings);
                                    break;
                                }

                                case "open": {
                                    buildString(text, "open", a11yStrings);
                                    break;
                                }

                                case "punct": {
                                    buildString(text, "punct", a11yStrings);
                                    break;
                                }

                                case "rel": {
                                    buildString(text, "rel", a11yStrings);
                                    break;
                                }

                                default: {
                                    tree.family;
                                    throw new Error("\"" + tree.family + "\" is not a valid atom type");
                                }
                            }

                            break;
                        }

                        case "color": {
                            var color = tree.color.replace(/katex-/, "");
                            buildRegion(a11yStrings, function (regionStrings) {
                                regionStrings.push("start color " + color);
                                buildA11yStrings(tree.body, regionStrings, atomType);
                                regionStrings.push("end color " + color);
                            });
                            break;
                        }

                        case "color-token": {
                            // Used by \color, \colorbox, and \fcolorbox but not directly rendered.
                            // It's a leaf node and has no children so just break.
                            break;
                        }

                        case "delimsizing": {
                            if (tree.delim && tree.delim !== ".") {
                                buildString(tree.delim, "normal", a11yStrings);
                            }

                            break;
                        }

                        case "genfrac": {
                            buildRegion(a11yStrings, function (regionStrings) {
                                // genfrac can have unbalanced delimiters
                                var leftDelim = tree.leftDelim,
                                    rightDelim = tree.rightDelim; // NOTE: Not sure if this is a safe assumption
                                // hasBarLine true -> fraction, false -> binomial

                                if (tree.hasBarLine) {
                                    regionStrings.push("start fraction");
                                    leftDelim && buildString(leftDelim, "open", regionStrings);
                                    buildA11yStrings(tree.numer, regionStrings, atomType);
                                    regionStrings.push("divided by");
                                    buildA11yStrings(tree.denom, regionStrings, atomType);
                                    rightDelim && buildString(rightDelim, "close", regionStrings);
                                    regionStrings.push("end fraction");
                                } else {
                                    regionStrings.push("start binomial");
                                    leftDelim && buildString(leftDelim, "open", regionStrings);
                                    buildA11yStrings(tree.numer, regionStrings, atomType);
                                    regionStrings.push("over");
                                    buildA11yStrings(tree.denom, regionStrings, atomType);
                                    rightDelim && buildString(rightDelim, "close", regionStrings);
                                    regionStrings.push("end binomial");
                                }
                            });
                            break;
                        }

                        case "kern": {
                            // No op: we don't attempt to present kerning information
                            // to the screen reader.
                            break;
                        }

                        case "leftright": {
                            buildRegion(a11yStrings, function (regionStrings) {
                                buildString(tree.left, "open", regionStrings);
                                buildA11yStrings(tree.body, regionStrings, atomType);
                                buildString(tree.right, "close", regionStrings);
                            });
                            break;
                        }

                        case "leftright-right": {
                            // TODO: double check that this is a no-op
                            break;
                        }

                        case "lap": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "mathord": {
                            buildString(tree.text, "normal", a11yStrings);
                            break;
                        }

                        case "op": {
                            var body = tree.body,
                                name = tree.name;

                            if (body) {
                                buildA11yStrings(body, a11yStrings, atomType);
                            } else if (name) {
                                buildString(name, "normal", a11yStrings);
                            }

                            break;
                        }

                        case "op-token": {
                            // Used internally by operator symbols.
                            buildString(tree.text, atomType, a11yStrings);
                            break;
                        }

                        case "ordgroup": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "overline": {
                            buildRegion(a11yStrings, function (a11yStrings) {
                                a11yStrings.push("start overline");
                                buildA11yStrings(tree.body, a11yStrings, atomType);
                                a11yStrings.push("end overline");
                            });
                            break;
                        }

                        case "phantom": {
                            a11yStrings.push("empty space");
                            break;
                        }

                        case "raisebox": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "rule": {
                            a11yStrings.push("rectangle");
                            break;
                        }

                        case "sizing": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "spacing": {
                            a11yStrings.push("space");
                            break;
                        }

                        case "styling": {
                            // We ignore the styling and just pass through the contents
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "sqrt": {
                            buildRegion(a11yStrings, function (regionStrings) {
                                var body = tree.body,
                                    index = tree.index;

                                if (index) {
                                    var indexString = flatten(buildA11yStrings(index, [], atomType)).join(",");

                                    if (indexString === "3") {
                                        regionStrings.push("cube root of");
                                        buildA11yStrings(body, regionStrings, atomType);
                                        regionStrings.push("end cube root");
                                        return;
                                    }

                                    regionStrings.push("root");
                                    regionStrings.push("start index");
                                    buildA11yStrings(index, regionStrings, atomType);
                                    regionStrings.push("end index");
                                    return;
                                }

                                regionStrings.push("square root of");
                                buildA11yStrings(body, regionStrings, atomType);
                                regionStrings.push("end square root");
                            });
                            break;
                        }

                        case "supsub": {
                            var base = tree.base,
                                sub = tree.sub,
                                sup = tree.sup;
                            var isLog = false;

                            if (base) {
                                buildA11yStrings(base, a11yStrings, atomType);
                                isLog = base.type === "op" && base.name === "\\log";
                            }

                            if (sub) {
                                var regionName = isLog ? "base" : "subscript";
                                buildRegion(a11yStrings, function (regionStrings) {
                                    regionStrings.push("start " + regionName);
                                    buildA11yStrings(sub, regionStrings, atomType);
                                    regionStrings.push("end " + regionName);
                                });
                            }

                            if (sup) {
                                buildRegion(a11yStrings, function (regionStrings) {
                                    var supString = flatten(buildA11yStrings(sup, [], atomType)).join(",");

                                    if (supString in powerMap) {
                                        regionStrings.push(powerMap[supString]);
                                        return;
                                    }

                                    regionStrings.push("start superscript");
                                    buildA11yStrings(sup, regionStrings, atomType);
                                    regionStrings.push("end superscript");
                                });
                            }

                            break;
                        }

                        case "text": {
                            // TODO: handle other fonts
                            if (tree.font === "\\textbf") {
                                buildRegion(a11yStrings, function (regionStrings) {
                                    regionStrings.push("start bold text");
                                    buildA11yStrings(tree.body, regionStrings, atomType);
                                    regionStrings.push("end bold text");
                                });
                                break;
                            }

                            buildRegion(a11yStrings, function (regionStrings) {
                                regionStrings.push("start text");
                                buildA11yStrings(tree.body, regionStrings, atomType);
                                regionStrings.push("end text");
                            });
                            break;
                        }

                        case "textord": {
                            buildString(tree.text, atomType, a11yStrings);
                            break;
                        }

                        case "smash": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "enclose": {
                            // TODO: create a map for these.
                            // TODO: differentiate between a body with a single atom, e.g.
                            // "cancel a" instead of "start cancel, a, end cancel"
                            if (/cancel/.test(tree.label)) {
                                buildRegion(a11yStrings, function (regionStrings) {
                                    regionStrings.push("start cancel");
                                    buildA11yStrings(tree.body, regionStrings, atomType);
                                    regionStrings.push("end cancel");
                                });
                                break;
                            } else if (/box/.test(tree.label)) {
                                buildRegion(a11yStrings, function (regionStrings) {
                                    regionStrings.push("start box");
                                    buildA11yStrings(tree.body, regionStrings, atomType);
                                    regionStrings.push("end box");
                                });
                                break;
                            } else if (/sout/.test(tree.label)) {
                                buildRegion(a11yStrings, function (regionStrings) {
                                    regionStrings.push("start strikeout");
                                    buildA11yStrings(tree.body, regionStrings, atomType);
                                    regionStrings.push("end strikeout");
                                });
                                break;
                            }

                            throw new Error("KaTeX-a11y: enclose node with " + tree.label + " not supported yet");
                        }

                        case "vphantom": {
                            throw new Error("KaTeX-a11y: vphantom not implemented yet");
                        }

                        case "hphantom": {
                            throw new Error("KaTeX-a11y: hphantom not implemented yet");
                        }

                        case "operatorname": {
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "array": {
                            throw new Error("KaTeX-a11y: array not implemented yet");
                        }

                        case "raw": {
                            throw new Error("KaTeX-a11y: raw not implemented yet");
                        }

                        case "size": {
                            // Although there are nodes of type "size" in the parse tree, they have
                            // no semantic meaning and should be ignored.
                            break;
                        }

                        case "url": {
                            throw new Error("KaTeX-a11y: url not implemented yet");
                        }

                        case "tag": {
                            throw new Error("KaTeX-a11y: tag not implemented yet");
                        }

                        case "verb": {
                            buildString("start verbatim", "normal", a11yStrings);
                            buildString(tree.body, "normal", a11yStrings);
                            buildString("end verbatim", "normal", a11yStrings);
                            break;
                        }

                        case "environment": {
                            throw new Error("KaTeX-a11y: environment not implemented yet");
                        }

                        case "horizBrace": {
                            buildString("start " + tree.label.slice(1), "normal", a11yStrings);
                            buildA11yStrings(tree.base, a11yStrings, atomType);
                            buildString("end " + tree.label.slice(1), "normal", a11yStrings);
                            break;
                        }

                        case "infix": {
                            // All infix nodes are replace with other nodes.
                            break;
                        }

                        case "includegraphics": {
                            throw new Error("KaTeX-a11y: includegraphics not implemented yet");
                        }

                        case "font": {
                            // TODO: callout the start/end of specific fonts
                            // TODO: map \BBb{N} to "the naturals" or something like that
                            buildA11yStrings(tree.body, a11yStrings, atomType);
                            break;
                        }

                        case "href": {
                            throw new Error("KaTeX-a11y: href not implemented yet");
                        }

                        case "cr": {
                            // This is used by environments.
                            throw new Error("KaTeX-a11y: cr not implemented yet");
                        }

                        case "underline": {
                            buildRegion(a11yStrings, function (a11yStrings) {
                                a11yStrings.push("start underline");
                                buildA11yStrings(tree.body, a11yStrings, atomType);
                                a11yStrings.push("end underline");
                            });
                            break;
                        }

                        case "xArrow": {
                            throw new Error("KaTeX-a11y: xArrow not implemented yet");
                        }

                        case "mclass": {
                            // \neq and \ne are macros so we let "htmlmathml" render the mathmal
                            // side of things and extract the text from that.
                            var _atomType = tree.mclass.slice(1); // $FlowFixMe: drop the leading "m" from the values in mclass


                            buildA11yStrings(tree.body, a11yStrings, _atomType);
                            break;
                        }

                        case "mathchoice": {
                            // TODO: track which which style we're using, e.g. dispaly, text, etc.
                            // default to text style if even that may not be the correct style
                            buildA11yStrings(tree.text, a11yStrings, atomType);
                            break;
                        }

                        case "htmlmathml": {
                            buildA11yStrings(tree.mathml, a11yStrings, atomType);
                            break;
                        }

                        case "middle": {
                            buildString(tree.delim, atomType, a11yStrings);
                            break;
                        }

                        default:
                            tree.type;
                            throw new Error("KaTeX a11y un-recognized type: " + tree.type);
                    }
                };

                var buildA11yStrings = function buildA11yStrings(tree, a11yStrings, atomType) {
                    if (a11yStrings === void 0) {
                        a11yStrings = [];
                    }

                    if (tree instanceof Array) {
                        for (var i = 0; i < tree.length; i++) {
                            buildA11yStrings(tree[i], a11yStrings, atomType);
                        }
                    } else {
                        handleObject(tree, a11yStrings, atomType);
                    }

                    return a11yStrings;
                };

                var flatten = function flatten(array) {
                    var result = [];
                    array.forEach(function (item) {
                        if (item instanceof Array) {
                            result = result.concat(flatten(item));
                        } else {
                            result.push(item);
                        }
                    });
                    return result;
                };

                var renderA11yString = function renderA11yString(text, settings) {
                    var tree = katex__WEBPACK_IMPORTED_MODULE_0___default.a.__parse(text, settings);

                    var a11yStrings = buildA11yStrings(tree, [], "normal");
                    return flatten(a11yStrings).join(", ");
                };

                /* harmony default export */
                __webpack_exports__["default"] = (renderA11yString);

                /***/
            })
            /******/])["default"];
});